/**
 * @push 数组末尾添加
 *  @params 添加的项 
 *  @return 返回新数组长度
*/
let arr = [10, 20]
arr.push('boy', { name: 'lzw' })
// [ 10, 20, 'boy', { name: 'lzw' } ]

/**
 * @unshift 向数组开始位置增加内容
 *  @params 多个任意类型
 *  @return 新增后数组长度
*/
let arr2 = [30, 40]
arr2.unshift('zw', '60')
// [ 'zw', '60', 30, 40 ]

/**
 * @shift 删除数组第一项
 *  @params 空
 *  @return 删除的那一项
*/
let arr3 = [10, 20, 30]
arr3.shift()
// arr3.shift() 10
// [ 20, 30 ]
// - (不能实现)基于原生js中的delete 可以删除某一项 但是不会影响数组本身结构 langth长度不会修改
delete arr3[0]
// [ <1 empty item>, 20, 30 ] 

/**
 * @pop 删除数组最后一项
 *  @params 空
 *  @return 删除的那一项
*/
let arr4 = [18, 26, 30]
arr4.pop()
// arr4.pop() 30
// [ 18, 26 ]
// - 原生js
arr4.length--

/**
 * @splice 数组的万能方法(增，删，改)
 *  @params  
 *      n :number, m :number, x: any  从下标n开始 删除m个元素(m不写 是删除到末尾) x代表占用删除的部分
 *      0 :number 清空数组 添加的项会从n 前面添加
 *      n, 0, x 从下标n开始删除0项 添加x元素 新增
 *  @return 
 *      把删除的部分用新数组储存起来 返回
*/
// 删除
let ary = [10, 20, 30, 40, 50, 60, 70, 80, 90]
let res = ary.splice(2, 3)
// ary [10, 20 , 60, 70, 80, 90] res [30, 40, 50]
// 清空数组
let res2 = ary.splice(0)
// ary [] res [10, 20 , 60, 70, 80, 90]
// 删除最后一项
ary.splice(ary.length - 1)
// 删除第一项
// ary.aplice(0, 1)
ary = [10, 20, 30, 40, 50]
// 修改
ary.splice(1, 2, 'zw', 'zhangsan', 'zz')
// ary[ 10, 'zw', 'zhangsan', 'zz', 40, 50 ]

// ============================================================
/* 不改变原数组 */
/**
 * @conct : 实现数组的拼接
 *  @params 多个任意类型的值
 *  @return 拼接后的新数组(原数组不变)
*/
let arr5 = [1, 2, 3, 4]
let arr6 = [7, 8]
arr5.concat('new', arr6)
// [1, 2, 3, 4, 'new', 7, 8]

/**
 * @tostring 把数组转换为字符串 原属组不变
 *  @params 空
 *  @return 转换后的字符串
 * 
*/
let arr7 = [1, 2, 3, 20]
// '1,2,3,20'

/**
 * @join 把数组转换为字符串
 * @params 分隔的符号 为空是逗号
 * @return 返回分隔号的字符串
*/
let arr8 = [1, 2, 5, 6, 7]
// console.log(eval(arr8.join('+')));
/**
 * @eval 把字符串转换为js 表达式
 * 数组相加 eval(arr8.join('+'))
 * 数组相减 eval(arr8.join('-'))
 * */

/**
 * @indexOf 检测数组中是否包含某一项(第一次出现的位置)
 *  @params 传入需要查询的项
 *  @return 返回符合条件元素的下标 如果有返回索引 如果没有返回-1
*/

/**
 * @indexOf 检测数组中是否包含某一项(最后一次出现的位置)
 *  @params 传入需要查询的项
 *  @return 返回符合条件元素的下标如果有返回索引 如果没有返回-1·
*/

// ====================================================================

/**
 * 数组的查询和拼接
 *  @slice 原数组不会改变
 *      @params n,m 从索引n开始，找到索引m（不包含m），找到的部分新数组返回 m不写找到末尾
 *      @return 返回找到的部分返回
*/
let arr9 = [1, 4, 5, 6, 7, 89, 67, 677]
arr9.slice(3, 7)
// [6, 7, 8, 9, 67]
arr9.slice(0) // 数组克隆 (浅克隆)
// 如果是负数 从后往前数， 小数会忽略

/**
 * 把数组倒过来排列
 * @reverse
 *  @params 无
 *  @return 排列后的新数组 (原数组会改变)
*/
let arr10 = [0, 3, 4, 56, 'zs']
// ['zs', 56, 4, 3, 0]

/**
 * 数组排序
 * @sort
 *  @params 可有可无 参数是个函数 （如果不传递参数，没办法处理10以上的数字）
 *  @return 排序后的新数组 （原数组会改变）
*/

/**
 * 数组去重方法 =============================================================
*/
// includes 或 indexOf ie8不支持
let arr11 = [1, 2, 3, 1, 2, 2, 2, 1, 1, 3, 2, 1, 1, 3, 2]
let newArr11 = []
arr11.includes()
arr11.forEach(i => {
    if (!newArr11.includes(i)) newArr11.push(i);
})
// 数组塌陷问题
let arr12 = [1, 2, 3, 1, 2, 2, 2, 1, 1, 3, 2, 1, 1, 3, 2]
for (var i = 0; i < arr12.length; i++) {
    for (var j = i + 1; j < arr12.length; j++) {
        if (arr12[i] === arr12[j]) {
            arr12.splice(j, 1);
            i--;
        }
    }
}
// 对象去重方式
let arr13 = [1, 2, 3, 1, 2, 2, 2, 1, 1, 3, 2, 1, 1, 3, 2];
let obj = {};
for (var i = 0; i < arr13.length; i++) {
    if(obj[arr13[i]] !== undefined) {
        arr13.splice(i, 1);
        i--;
        continue;
    }
    obj[arr13[i]] = arr13[i]
}
// 基于splice 删除性能不好 因为删除重复项会导致后面所有项的下标都会改变
// 把重复项放到最后删除 然后i--继续查重
let arr14 = [1, 2, 3, 1, 2, 2, 2, 1, 1, 3, 2, 1, 1, 3, 2];
let obj2 = {};
for(var i = 0; i < arr14.length; i++) {
    if (obj2[arr14[i]] !== undefined) {
        arr14[i] = arr14[arr14.length - 1];
        arr14.length--;
        i--;
        continue;
    }
    obj2[arr14[i]] = arr14[i]
}



/**
 * 
 * 
 * 删除数组最后一项
 *  arr.pop()
 *  arr.length--
 *  arr.splice(ary.length - 1)
 * 
*/

